/* Do not change, this code is generated from Golang structs */


export class DaemonSetCondition {
  type: string;
  status: string;
  lastTransitionTime: Time;
  reason: string;
  message: string;

  constructor(init?: DaemonSetCondition) {
    if (!init) return ;
    if (init.type) this.type = init.type;
    if (init.status) this.status = init.status;
    if (init.lastTransitionTime) this.lastTransitionTime = init.lastTransitionTime;
    if (init.reason) this.reason = init.reason;
    if (init.message) this.message = init.message;
  }


  static emptyObject(): DaemonSetCondition {
    let result = new DaemonSetCondition();
    result.lastTransitionTime = Time.emptyObject();
    return result;
  }

}
export class DaemonSetStatus {
  currentNumberScheduled: number;
  numberMisscheduled: number;
  desiredNumberScheduled: number;
  numberReady: number;
  observedGeneration: number;
  updatedNumberScheduled: number;
  numberAvailable: number;
  numberUnavailable: number;
  collisionCount?: number;
  conditions: DaemonSetCondition[];

  constructor(init?: DaemonSetStatus) {
    if (!init) return ;
    if (init.currentNumberScheduled) this.currentNumberScheduled = init.currentNumberScheduled;
    if (init.numberMisscheduled) this.numberMisscheduled = init.numberMisscheduled;
    if (init.desiredNumberScheduled) this.desiredNumberScheduled = init.desiredNumberScheduled;
    if (init.numberReady) this.numberReady = init.numberReady;
    if (init.observedGeneration) this.observedGeneration = init.observedGeneration;
    if (init.updatedNumberScheduled) this.updatedNumberScheduled = init.updatedNumberScheduled;
    if (init.numberAvailable) this.numberAvailable = init.numberAvailable;
    if (init.numberUnavailable) this.numberUnavailable = init.numberUnavailable;
    if (init.collisionCount) this.collisionCount = init.collisionCount;
    if (init.conditions) this.conditions = init.conditions;
  }


  static emptyObject(): DaemonSetStatus {
    let result = new DaemonSetStatus();
    result.conditions = [];
    return result;
  }

}

export class RollingUpdateDaemonSet {
  maxUnavailable?: IntOrString;

  constructor(init?: RollingUpdateDaemonSet) {
    if (!init) return ;
    if (init.maxUnavailable) this.maxUnavailable = init.maxUnavailable;
  }


  static emptyObject(): RollingUpdateDaemonSet {
    let result = new RollingUpdateDaemonSet();
    result.maxUnavailable = IntOrString.emptyObject();
    return result;
  }

}
export class DaemonSetUpdateStrategy {
  type: string;
  rollingUpdate?: RollingUpdateDaemonSet;

  constructor(init?: DaemonSetUpdateStrategy) {
    if (!init) return ;
    if (init.type) this.type = init.type;
    if (init.rollingUpdate) this.rollingUpdate = init.rollingUpdate;
  }


  static emptyObject(): DaemonSetUpdateStrategy {
    let result = new DaemonSetUpdateStrategy();
    result.rollingUpdate = RollingUpdateDaemonSet.emptyObject();
    return result;
  }

}
export class PodDNSConfigOption {
  name: string;
  value?: string;

  constructor(init?: PodDNSConfigOption) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.value) this.value = init.value;
  }


  static emptyObject(): PodDNSConfigOption {
    let result = new PodDNSConfigOption();
    return result;
  }

}
export class PodDNSConfig {
  nameservers: string[];
  searches: string[];
  options: PodDNSConfigOption[];

  constructor(init?: PodDNSConfig) {
    if (!init) return ;
    if (init.nameservers) this.nameservers = init.nameservers;
    if (init.searches) this.searches = init.searches;
    if (init.options) this.options = init.options;
  }


  static emptyObject(): PodDNSConfig {
    let result = new PodDNSConfig();
    result.nameservers = [];
    result.searches = [];
    result.options = [];
    return result;
  }

}
export class HostAlias {
  ip: string;
  hostnames: string[];

  constructor(init?: HostAlias) {
    if (!init) return ;
    if (init.ip) this.ip = init.ip;
    if (init.hostnames) this.hostnames = init.hostnames;
  }


  static emptyObject(): HostAlias {
    let result = new HostAlias();
    result.hostnames = [];
    return result;
  }

}
export class Toleration {
  key: string;
  operator: string;
  value: string;
  effect: string;
  tolerationSeconds?: number;

  constructor(init?: Toleration) {
    if (!init) return ;
    if (init.key) this.key = init.key;
    if (init.operator) this.operator = init.operator;
    if (init.value) this.value = init.value;
    if (init.effect) this.effect = init.effect;
    if (init.tolerationSeconds) this.tolerationSeconds = init.tolerationSeconds;
  }


  static emptyObject(): Toleration {
    let result = new Toleration();
    return result;
  }

}


export class PodAntiAffinity {
  requiredDuringSchedulingIgnoredDuringExecution: PodAffinityTerm[];
  preferredDuringSchedulingIgnoredDuringExecution: WeightedPodAffinityTerm[];

  constructor(init?: PodAntiAffinity) {
    if (!init) return ;
    if (init.requiredDuringSchedulingIgnoredDuringExecution) this.requiredDuringSchedulingIgnoredDuringExecution = init.requiredDuringSchedulingIgnoredDuringExecution;
    if (init.preferredDuringSchedulingIgnoredDuringExecution) this.preferredDuringSchedulingIgnoredDuringExecution = init.preferredDuringSchedulingIgnoredDuringExecution;
  }


  static emptyObject(): PodAntiAffinity {
    let result = new PodAntiAffinity();
    result.requiredDuringSchedulingIgnoredDuringExecution = [];
    result.preferredDuringSchedulingIgnoredDuringExecution = [];
    return result;
  }

}

export class WeightedPodAffinityTerm {
  weight: number;
  podAffinityTerm: PodAffinityTerm;

  constructor(init?: WeightedPodAffinityTerm) {
    if (!init) return ;
    if (init.weight) this.weight = init.weight;
    if (init.podAffinityTerm) this.podAffinityTerm = init.podAffinityTerm;
  }


  static emptyObject(): WeightedPodAffinityTerm {
    let result = new WeightedPodAffinityTerm();
    result.podAffinityTerm = PodAffinityTerm.emptyObject();
    return result;
  }

}

export class PodAffinityTerm {
  labelSelector?: LabelSelector;
  namespaces: string[];
  topologyKey: string;

  constructor(init?: PodAffinityTerm) {
    if (!init) return ;
    if (init.labelSelector) this.labelSelector = init.labelSelector;
    if (init.namespaces) this.namespaces = init.namespaces;
    if (init.topologyKey) this.topologyKey = init.topologyKey;
  }


  static emptyObject(): PodAffinityTerm {
    let result = new PodAffinityTerm();
    result.labelSelector = LabelSelector.emptyObject();
    result.namespaces = [];
    return result;
  }

}
export class PodAffinity {
  requiredDuringSchedulingIgnoredDuringExecution: PodAffinityTerm[];
  preferredDuringSchedulingIgnoredDuringExecution: WeightedPodAffinityTerm[];

  constructor(init?: PodAffinity) {
    if (!init) return ;
    if (init.requiredDuringSchedulingIgnoredDuringExecution) this.requiredDuringSchedulingIgnoredDuringExecution = init.requiredDuringSchedulingIgnoredDuringExecution;
    if (init.preferredDuringSchedulingIgnoredDuringExecution) this.preferredDuringSchedulingIgnoredDuringExecution = init.preferredDuringSchedulingIgnoredDuringExecution;
  }


  static emptyObject(): PodAffinity {
    let result = new PodAffinity();
    result.requiredDuringSchedulingIgnoredDuringExecution = [];
    result.preferredDuringSchedulingIgnoredDuringExecution = [];
    return result;
  }

}

export class PreferredSchedulingTerm {
  weight: number;
  preference: NodeSelectorTerm;

  constructor(init?: PreferredSchedulingTerm) {
    if (!init) return ;
    if (init.weight) this.weight = init.weight;
    if (init.preference) this.preference = init.preference;
  }


  static emptyObject(): PreferredSchedulingTerm {
    let result = new PreferredSchedulingTerm();
    result.preference = NodeSelectorTerm.emptyObject();
    return result;
  }

}
export class NodeSelectorRequirement {
  key: string;
  operator: string;
  values: string[];

  constructor(init?: NodeSelectorRequirement) {
    if (!init) return ;
    if (init.key) this.key = init.key;
    if (init.operator) this.operator = init.operator;
    if (init.values) this.values = init.values;
  }


  static emptyObject(): NodeSelectorRequirement {
    let result = new NodeSelectorRequirement();
    result.values = [];
    return result;
  }

}
export class NodeSelectorTerm {
  matchExpressions: NodeSelectorRequirement[];

  constructor(init?: NodeSelectorTerm) {
    if (!init) return ;
    if (init.matchExpressions) this.matchExpressions = init.matchExpressions;
  }


  static emptyObject(): NodeSelectorTerm {
    let result = new NodeSelectorTerm();
    result.matchExpressions = [];
    return result;
  }

}
export class NodeSelector {
  nodeSelectorTerms: NodeSelectorTerm[];

  constructor(init?: NodeSelector) {
    if (!init) return ;
    if (init.nodeSelectorTerms) this.nodeSelectorTerms = init.nodeSelectorTerms;
  }


  static emptyObject(): NodeSelector {
    let result = new NodeSelector();
    result.nodeSelectorTerms = [];
    return result;
  }

}
export class NodeAffinity {
  requiredDuringSchedulingIgnoredDuringExecution?: NodeSelector;
  preferredDuringSchedulingIgnoredDuringExecution: PreferredSchedulingTerm[];

  constructor(init?: NodeAffinity) {
    if (!init) return ;
    if (init.requiredDuringSchedulingIgnoredDuringExecution) this.requiredDuringSchedulingIgnoredDuringExecution = init.requiredDuringSchedulingIgnoredDuringExecution;
    if (init.preferredDuringSchedulingIgnoredDuringExecution) this.preferredDuringSchedulingIgnoredDuringExecution = init.preferredDuringSchedulingIgnoredDuringExecution;
  }


  static emptyObject(): NodeAffinity {
    let result = new NodeAffinity();
    result.requiredDuringSchedulingIgnoredDuringExecution = NodeSelector.emptyObject();
    result.preferredDuringSchedulingIgnoredDuringExecution = [];
    return result;
  }

}
export class Affinity {
  nodeAffinity?: NodeAffinity;
  podAffinity?: PodAffinity;
  podAntiAffinity?: PodAntiAffinity;

  constructor(init?: Affinity) {
    if (!init) return ;
    if (init.nodeAffinity) this.nodeAffinity = init.nodeAffinity;
    if (init.podAffinity) this.podAffinity = init.podAffinity;
    if (init.podAntiAffinity) this.podAntiAffinity = init.podAntiAffinity;
  }


  static emptyObject(): Affinity {
    let result = new Affinity();
    result.nodeAffinity = NodeAffinity.emptyObject();
    result.podAffinity = PodAffinity.emptyObject();
    result.podAntiAffinity = PodAntiAffinity.emptyObject();
    return result;
  }

}


export class PodSecurityContext {
  seLinuxOptions?: SELinuxOptions;
  runAsUser?: number;
  runAsGroup?: number;
  runAsNonRoot?: boolean;
  supplementalGroups: number[];
  fsGroup?: number;

  constructor(init?: PodSecurityContext) {
    if (!init) return ;
    if (init.seLinuxOptions) this.seLinuxOptions = init.seLinuxOptions;
    if (init.runAsUser) this.runAsUser = init.runAsUser;
    if (init.runAsGroup) this.runAsGroup = init.runAsGroup;
    if (init.runAsNonRoot) this.runAsNonRoot = init.runAsNonRoot;
    if (init.supplementalGroups) this.supplementalGroups = init.supplementalGroups;
    if (init.fsGroup) this.fsGroup = init.fsGroup;
  }


  static emptyObject(): PodSecurityContext {
    let result = new PodSecurityContext();
    result.seLinuxOptions = SELinuxOptions.emptyObject();
    result.supplementalGroups = [];
    return result;
  }

}

export class SELinuxOptions {
  user: string;
  role: string;
  type: string;
  level: string;

  constructor(init?: SELinuxOptions) {
    if (!init) return ;
    if (init.user) this.user = init.user;
    if (init.role) this.role = init.role;
    if (init.type) this.type = init.type;
    if (init.level) this.level = init.level;
  }


  static emptyObject(): SELinuxOptions {
    let result = new SELinuxOptions();
    return result;
  }

}
export class Capabilities {
  add: string[];
  drop: string[];

  constructor(init?: Capabilities) {
    if (!init) return ;
    if (init.add) this.add = init.add;
    if (init.drop) this.drop = init.drop;
  }


  static emptyObject(): Capabilities {
    let result = new Capabilities();
    result.add = [];
    result.drop = [];
    return result;
  }

}
export class SecurityContext {
  capabilities?: Capabilities;
  privileged?: boolean;
  seLinuxOptions?: SELinuxOptions;
  runAsUser?: number;
  runAsGroup?: number;
  runAsNonRoot?: boolean;
  readOnlyRootFilesystem?: boolean;
  allowPrivilegeEscalation?: boolean;

  constructor(init?: SecurityContext) {
    if (!init) return ;
    if (init.capabilities) this.capabilities = init.capabilities;
    if (init.privileged) this.privileged = init.privileged;
    if (init.seLinuxOptions) this.seLinuxOptions = init.seLinuxOptions;
    if (init.runAsUser) this.runAsUser = init.runAsUser;
    if (init.runAsGroup) this.runAsGroup = init.runAsGroup;
    if (init.runAsNonRoot) this.runAsNonRoot = init.runAsNonRoot;
    if (init.readOnlyRootFilesystem) this.readOnlyRootFilesystem = init.readOnlyRootFilesystem;
    if (init.allowPrivilegeEscalation) this.allowPrivilegeEscalation = init.allowPrivilegeEscalation;
  }


  static emptyObject(): SecurityContext {
    let result = new SecurityContext();
    result.capabilities = Capabilities.emptyObject();
    result.seLinuxOptions = SELinuxOptions.emptyObject();
    return result;
  }

}




export class Handler {
  exec?: ExecAction;
  httpGet?: HTTPGetAction;
  tcpSocket?: TCPSocketAction;

  constructor(init?: Handler) {
    if (!init) return ;
    if (init.exec) this.exec = init.exec;
    if (init.httpGet) this.httpGet = init.httpGet;
    if (init.tcpSocket) this.tcpSocket = init.tcpSocket;
  }


  static emptyObject(): Handler {
    let result = new Handler();
    result.exec = ExecAction.emptyObject();
    result.httpGet = HTTPGetAction.emptyObject();
    result.tcpSocket = TCPSocketAction.emptyObject();
    return result;
  }

}
export class Lifecycle {
  postStart?: Handler;
  preStop?: Handler;

  constructor(init?: Lifecycle) {
    if (!init) return ;
    if (init.postStart) this.postStart = init.postStart;
    if (init.preStop) this.preStop = init.preStop;
  }


  static emptyObject(): Lifecycle {
    let result = new Lifecycle();
    result.postStart = Handler.emptyObject();
    result.preStop = Handler.emptyObject();
    return result;
  }

}


export class TCPSocketAction {
  port: IntOrString;
  host: string;

  constructor(init?: TCPSocketAction) {
    if (!init) return ;
    if (init.port) this.port = init.port;
    if (init.host) this.host = init.host;
  }


  static emptyObject(): TCPSocketAction {
    let result = new TCPSocketAction();
    result.port = IntOrString.emptyObject();
    return result;
  }

}
export class HTTPHeader {
  name: string;
  value: string;

  constructor(init?: HTTPHeader) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.value) this.value = init.value;
  }


  static emptyObject(): HTTPHeader {
    let result = new HTTPHeader();
    return result;
  }

}
export class IntOrString {
  Type: number;
  IntVal: number;
  StrVal: string;

  constructor(init?: IntOrString) {
    if (!init) return ;
    if (init.Type) this.Type = init.Type;
    if (init.IntVal) this.IntVal = init.IntVal;
    if (init.StrVal) this.StrVal = init.StrVal;
  }


  static emptyObject(): IntOrString {
    let result = new IntOrString();
    return result;
  }

}
export class HTTPGetAction {
  path: string;
  port: IntOrString;
  host: string;
  scheme: string;
  httpHeaders: HTTPHeader[];

  constructor(init?: HTTPGetAction) {
    if (!init) return ;
    if (init.path) this.path = init.path;
    if (init.port) this.port = init.port;
    if (init.host) this.host = init.host;
    if (init.scheme) this.scheme = init.scheme;
    if (init.httpHeaders) this.httpHeaders = init.httpHeaders;
  }


  static emptyObject(): HTTPGetAction {
    let result = new HTTPGetAction();
    result.port = IntOrString.emptyObject();
    result.httpHeaders = [];
    return result;
  }

}
export class ExecAction {
  command: string[];

  constructor(init?: ExecAction) {
    if (!init) return ;
    if (init.command) this.command = init.command;
  }


  static emptyObject(): ExecAction {
    let result = new ExecAction();
    result.command = [];
    return result;
  }

}
export class Probe {
  exec?: ExecAction;
  httpGet?: HTTPGetAction;
  tcpSocket?: TCPSocketAction;
  initialDelaySeconds: number;
  timeoutSeconds: number;
  periodSeconds: number;
  successThreshold: number;
  failureThreshold: number;

  constructor(init?: Probe) {
    if (!init) return ;
    if (init.exec) this.exec = init.exec;
    if (init.httpGet) this.httpGet = init.httpGet;
    if (init.tcpSocket) this.tcpSocket = init.tcpSocket;
    if (init.initialDelaySeconds) this.initialDelaySeconds = init.initialDelaySeconds;
    if (init.timeoutSeconds) this.timeoutSeconds = init.timeoutSeconds;
    if (init.periodSeconds) this.periodSeconds = init.periodSeconds;
    if (init.successThreshold) this.successThreshold = init.successThreshold;
    if (init.failureThreshold) this.failureThreshold = init.failureThreshold;
  }


  static emptyObject(): Probe {
    let result = new Probe();
    result.exec = ExecAction.emptyObject();
    result.httpGet = HTTPGetAction.emptyObject();
    result.tcpSocket = TCPSocketAction.emptyObject();
    return result;
  }

}
export class VolumeDevice {
  name: string;
  devicePath: string;

  constructor(init?: VolumeDevice) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.devicePath) this.devicePath = init.devicePath;
  }


  static emptyObject(): VolumeDevice {
    let result = new VolumeDevice();
    return result;
  }

}
export class VolumeMount {
  name: string;
  readOnly: boolean;
  mountPath: string;
  subPath: string;
  mountPropagation?: string;

  constructor(init?: VolumeMount) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.mountPath) this.mountPath = init.mountPath;
    if (init.subPath) this.subPath = init.subPath;
    if (init.mountPropagation) this.mountPropagation = init.mountPropagation;
  }


  static emptyObject(): VolumeMount {
    let result = new VolumeMount();
    return result;
  }

}
export class ResourceRequirements {
  limits?: {[key: string]: any};
  requests?: {[key: string]: any};

  constructor(init?: ResourceRequirements) {
    if (!init) return ;
    if (init.limits) this.limits = init.limits;
    if (init.requests) this.requests = init.requests;
  }


  static emptyObject(): ResourceRequirements {
    let result = new ResourceRequirements();
    result.limits = null;
    result.requests = null;
    return result;
  }

}
export class SecretKeySelector {
  name: string;
  key: string;
  optional?: boolean;

  constructor(init?: SecretKeySelector) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.key) this.key = init.key;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): SecretKeySelector {
    let result = new SecretKeySelector();
    return result;
  }

}
export class ConfigMapKeySelector {
  name: string;
  key: string;
  optional?: boolean;

  constructor(init?: ConfigMapKeySelector) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.key) this.key = init.key;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): ConfigMapKeySelector {
    let result = new ConfigMapKeySelector();
    return result;
  }

}


export class EnvVarSource {
  fieldRef?: ObjectFieldSelector;
  resourceFieldRef?: ResourceFieldSelector;
  configMapKeyRef?: ConfigMapKeySelector;
  secretKeyRef?: SecretKeySelector;

  constructor(init?: EnvVarSource) {
    if (!init) return ;
    if (init.fieldRef) this.fieldRef = init.fieldRef;
    if (init.resourceFieldRef) this.resourceFieldRef = init.resourceFieldRef;
    if (init.configMapKeyRef) this.configMapKeyRef = init.configMapKeyRef;
    if (init.secretKeyRef) this.secretKeyRef = init.secretKeyRef;
  }


  static emptyObject(): EnvVarSource {
    let result = new EnvVarSource();
    result.fieldRef = ObjectFieldSelector.emptyObject();
    result.resourceFieldRef = ResourceFieldSelector.emptyObject();
    result.configMapKeyRef = ConfigMapKeySelector.emptyObject();
    result.secretKeyRef = SecretKeySelector.emptyObject();
    return result;
  }

}
export class EnvVar {
  name: string;
  value: string;
  valueFrom?: EnvVarSource;

  constructor(init?: EnvVar) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.value) this.value = init.value;
    if (init.valueFrom) this.valueFrom = init.valueFrom;
  }


  static emptyObject(): EnvVar {
    let result = new EnvVar();
    result.valueFrom = EnvVarSource.emptyObject();
    return result;
  }

}
export class SecretEnvSource {
  name: string;
  optional?: boolean;

  constructor(init?: SecretEnvSource) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): SecretEnvSource {
    let result = new SecretEnvSource();
    return result;
  }

}
export class ConfigMapEnvSource {
  name: string;
  optional?: boolean;

  constructor(init?: ConfigMapEnvSource) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): ConfigMapEnvSource {
    let result = new ConfigMapEnvSource();
    return result;
  }

}
export class EnvFromSource {
  prefix: string;
  configMapRef?: ConfigMapEnvSource;
  secretRef?: SecretEnvSource;

  constructor(init?: EnvFromSource) {
    if (!init) return ;
    if (init.prefix) this.prefix = init.prefix;
    if (init.configMapRef) this.configMapRef = init.configMapRef;
    if (init.secretRef) this.secretRef = init.secretRef;
  }


  static emptyObject(): EnvFromSource {
    let result = new EnvFromSource();
    result.configMapRef = ConfigMapEnvSource.emptyObject();
    result.secretRef = SecretEnvSource.emptyObject();
    return result;
  }

}
export class ContainerPort {
  name: string;
  hostPort: number;
  containerPort: number;
  protocol: string;
  hostIP: string;

  constructor(init?: ContainerPort) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.hostPort) this.hostPort = init.hostPort;
    if (init.containerPort) this.containerPort = init.containerPort;
    if (init.protocol) this.protocol = init.protocol;
    if (init.hostIP) this.hostIP = init.hostIP;
  }


  static emptyObject(): ContainerPort {
    let result = new ContainerPort();
    return result;
  }

}
export class Container {
  name: string;
  image: string;
  command: string[];
  args: string[];
  workingDir: string;
  ports: ContainerPort[];
  envFrom: EnvFromSource[];
  env: EnvVar[];
  resources: ResourceRequirements;
  volumeMounts: VolumeMount[];
  volumeDevices: VolumeDevice[];
  livenessProbe?: Probe;
  readinessProbe?: Probe;
  lifecycle?: Lifecycle;
  terminationMessagePath: string;
  terminationMessagePolicy: string;
  imagePullPolicy: string;
  securityContext?: SecurityContext;
  stdin: boolean;
  stdinOnce: boolean;
  tty: boolean;

  constructor(init?: Container) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.image) this.image = init.image;
    if (init.command) this.command = init.command;
    if (init.args) this.args = init.args;
    if (init.workingDir) this.workingDir = init.workingDir;
    if (init.ports) this.ports = init.ports;
    if (init.envFrom) this.envFrom = init.envFrom;
    if (init.env) this.env = init.env;
    if (init.resources) this.resources = init.resources;
    if (init.volumeMounts) this.volumeMounts = init.volumeMounts;
    if (init.volumeDevices) this.volumeDevices = init.volumeDevices;
    if (init.livenessProbe) this.livenessProbe = init.livenessProbe;
    if (init.readinessProbe) this.readinessProbe = init.readinessProbe;
    if (init.lifecycle) this.lifecycle = init.lifecycle;
    if (init.terminationMessagePath) this.terminationMessagePath = init.terminationMessagePath;
    if (init.terminationMessagePolicy) this.terminationMessagePolicy = init.terminationMessagePolicy;
    if (init.imagePullPolicy) this.imagePullPolicy = init.imagePullPolicy;
    if (init.securityContext) this.securityContext = init.securityContext;
    if (init.stdin) this.stdin = init.stdin;
    if (init.stdinOnce) this.stdinOnce = init.stdinOnce;
    if (init.tty) this.tty = init.tty;
  }


  static emptyObject(): Container {
    let result = new Container();
    result.command = [];
    result.args = [];
    result.ports = [];
    result.envFrom = [];
    result.env = [];
    result.resources = ResourceRequirements.emptyObject();
    result.volumeMounts = [];
    result.volumeDevices = [];
    result.livenessProbe = Probe.emptyObject();
    result.readinessProbe = Probe.emptyObject();
    result.lifecycle = Lifecycle.emptyObject();
    result.securityContext = SecurityContext.emptyObject();
    return result;
  }

}

export class StorageOSVolumeSource {
  volumeName: string;
  volumeNamespace: string;
  fsType: string;
  readOnly: boolean;
  secretRef?: LocalObjectReference;

  constructor(init?: StorageOSVolumeSource) {
    if (!init) return ;
    if (init.volumeName) this.volumeName = init.volumeName;
    if (init.volumeNamespace) this.volumeNamespace = init.volumeNamespace;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.secretRef) this.secretRef = init.secretRef;
  }


  static emptyObject(): StorageOSVolumeSource {
    let result = new StorageOSVolumeSource();
    result.secretRef = LocalObjectReference.emptyObject();
    return result;
  }

}

export class ScaleIOVolumeSource {
  gateway: string;
  system: string;
  secretRef?: LocalObjectReference;
  sslEnabled: boolean;
  protectionDomain: string;
  storagePool: string;
  storageMode: string;
  volumeName: string;
  fsType: string;
  readOnly: boolean;

  constructor(init?: ScaleIOVolumeSource) {
    if (!init) return ;
    if (init.gateway) this.gateway = init.gateway;
    if (init.system) this.system = init.system;
    if (init.secretRef) this.secretRef = init.secretRef;
    if (init.sslEnabled) this.sslEnabled = init.sslEnabled;
    if (init.protectionDomain) this.protectionDomain = init.protectionDomain;
    if (init.storagePool) this.storagePool = init.storagePool;
    if (init.storageMode) this.storageMode = init.storageMode;
    if (init.volumeName) this.volumeName = init.volumeName;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): ScaleIOVolumeSource {
    let result = new ScaleIOVolumeSource();
    result.secretRef = LocalObjectReference.emptyObject();
    return result;
  }

}
export class PortworxVolumeSource {
  volumeID: string;
  fsType: string;
  readOnly: boolean;

  constructor(init?: PortworxVolumeSource) {
    if (!init) return ;
    if (init.volumeID) this.volumeID = init.volumeID;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): PortworxVolumeSource {
    let result = new PortworxVolumeSource();
    return result;
  }

}

export class ConfigMapProjection {
  name: string;
  items: KeyToPath[];
  optional?: boolean;

  constructor(init?: ConfigMapProjection) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.items) this.items = init.items;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): ConfigMapProjection {
    let result = new ConfigMapProjection();
    result.items = [];
    return result;
  }

}

export class DownwardAPIProjection {
  items: DownwardAPIVolumeFile[];

  constructor(init?: DownwardAPIProjection) {
    if (!init) return ;
    if (init.items) this.items = init.items;
  }


  static emptyObject(): DownwardAPIProjection {
    let result = new DownwardAPIProjection();
    result.items = [];
    return result;
  }

}

export class SecretProjection {
  name: string;
  items: KeyToPath[];
  optional?: boolean;

  constructor(init?: SecretProjection) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.items) this.items = init.items;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): SecretProjection {
    let result = new SecretProjection();
    result.items = [];
    return result;
  }

}
export class VolumeProjection {
  secret?: SecretProjection;
  downwardAPI?: DownwardAPIProjection;
  configMap?: ConfigMapProjection;

  constructor(init?: VolumeProjection) {
    if (!init) return ;
    if (init.secret) this.secret = init.secret;
    if (init.downwardAPI) this.downwardAPI = init.downwardAPI;
    if (init.configMap) this.configMap = init.configMap;
  }


  static emptyObject(): VolumeProjection {
    let result = new VolumeProjection();
    result.secret = SecretProjection.emptyObject();
    result.downwardAPI = DownwardAPIProjection.emptyObject();
    result.configMap = ConfigMapProjection.emptyObject();
    return result;
  }

}
export class ProjectedVolumeSource {
  sources: VolumeProjection[];
  defaultMode?: number;

  constructor(init?: ProjectedVolumeSource) {
    if (!init) return ;
    if (init.sources) this.sources = init.sources;
    if (init.defaultMode) this.defaultMode = init.defaultMode;
  }


  static emptyObject(): ProjectedVolumeSource {
    let result = new ProjectedVolumeSource();
    result.sources = [];
    return result;
  }

}
export class PhotonPersistentDiskVolumeSource {
  pdID: string;
  fsType: string;

  constructor(init?: PhotonPersistentDiskVolumeSource) {
    if (!init) return ;
    if (init.pdID) this.pdID = init.pdID;
    if (init.fsType) this.fsType = init.fsType;
  }


  static emptyObject(): PhotonPersistentDiskVolumeSource {
    let result = new PhotonPersistentDiskVolumeSource();
    return result;
  }

}
export class AzureDiskVolumeSource {
  diskName: string;
  diskURI: string;
  cachingMode?: string;
  fsType?: string;
  readOnly?: boolean;
  kind?: string;

  constructor(init?: AzureDiskVolumeSource) {
    if (!init) return ;
    if (init.diskName) this.diskName = init.diskName;
    if (init.diskURI) this.diskURI = init.diskURI;
    if (init.cachingMode) this.cachingMode = init.cachingMode;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.kind) this.kind = init.kind;
  }


  static emptyObject(): AzureDiskVolumeSource {
    let result = new AzureDiskVolumeSource();
    return result;
  }

}
export class QuobyteVolumeSource {
  registry: string;
  volume: string;
  readOnly: boolean;
  user: string;
  group: string;

  constructor(init?: QuobyteVolumeSource) {
    if (!init) return ;
    if (init.registry) this.registry = init.registry;
    if (init.volume) this.volume = init.volume;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.user) this.user = init.user;
    if (init.group) this.group = init.group;
  }


  static emptyObject(): QuobyteVolumeSource {
    let result = new QuobyteVolumeSource();
    return result;
  }

}
export class VsphereVirtualDiskVolumeSource {
  volumePath: string;
  fsType: string;
  storagePolicyName: string;
  storagePolicyID: string;

  constructor(init?: VsphereVirtualDiskVolumeSource) {
    if (!init) return ;
    if (init.volumePath) this.volumePath = init.volumePath;
    if (init.fsType) this.fsType = init.fsType;
    if (init.storagePolicyName) this.storagePolicyName = init.storagePolicyName;
    if (init.storagePolicyID) this.storagePolicyID = init.storagePolicyID;
  }


  static emptyObject(): VsphereVirtualDiskVolumeSource {
    let result = new VsphereVirtualDiskVolumeSource();
    return result;
  }

}

export class ConfigMapVolumeSource {
  name: string;
  items: KeyToPath[];
  defaultMode?: number;
  optional?: boolean;

  constructor(init?: ConfigMapVolumeSource) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.items) this.items = init.items;
    if (init.defaultMode) this.defaultMode = init.defaultMode;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): ConfigMapVolumeSource {
    let result = new ConfigMapVolumeSource();
    result.items = [];
    return result;
  }

}
export class AzureFileVolumeSource {
  secretName: string;
  shareName: string;
  readOnly: boolean;

  constructor(init?: AzureFileVolumeSource) {
    if (!init) return ;
    if (init.secretName) this.secretName = init.secretName;
    if (init.shareName) this.shareName = init.shareName;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): AzureFileVolumeSource {
    let result = new AzureFileVolumeSource();
    return result;
  }

}
export class FCVolumeSource {
  targetWWNs: string[];
  lun?: number;
  fsType: string;
  readOnly: boolean;
  wwids: string[];

  constructor(init?: FCVolumeSource) {
    if (!init) return ;
    if (init.targetWWNs) this.targetWWNs = init.targetWWNs;
    if (init.lun) this.lun = init.lun;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.wwids) this.wwids = init.wwids;
  }


  static emptyObject(): FCVolumeSource {
    let result = new FCVolumeSource();
    result.targetWWNs = [];
    result.wwids = [];
    return result;
  }

}

export class ResourceFieldSelector {
  containerName: string;
  resource: string;
  divisor: Quantity;

  constructor(init?: ResourceFieldSelector) {
    if (!init) return ;
    if (init.containerName) this.containerName = init.containerName;
    if (init.resource) this.resource = init.resource;
    if (init.divisor) this.divisor = init.divisor;
  }


  static emptyObject(): ResourceFieldSelector {
    let result = new ResourceFieldSelector();
    result.divisor = Quantity.emptyObject();
    return result;
  }

}
export class ObjectFieldSelector {
  apiVersion: string;
  fieldPath: string;

  constructor(init?: ObjectFieldSelector) {
    if (!init) return ;
    if (init.apiVersion) this.apiVersion = init.apiVersion;
    if (init.fieldPath) this.fieldPath = init.fieldPath;
  }


  static emptyObject(): ObjectFieldSelector {
    let result = new ObjectFieldSelector();
    return result;
  }

}
export class DownwardAPIVolumeFile {
  path: string;
  fieldRef?: ObjectFieldSelector;
  resourceFieldRef?: ResourceFieldSelector;
  mode?: number;

  constructor(init?: DownwardAPIVolumeFile) {
    if (!init) return ;
    if (init.path) this.path = init.path;
    if (init.fieldRef) this.fieldRef = init.fieldRef;
    if (init.resourceFieldRef) this.resourceFieldRef = init.resourceFieldRef;
    if (init.mode) this.mode = init.mode;
  }


  static emptyObject(): DownwardAPIVolumeFile {
    let result = new DownwardAPIVolumeFile();
    result.fieldRef = ObjectFieldSelector.emptyObject();
    result.resourceFieldRef = ResourceFieldSelector.emptyObject();
    return result;
  }

}
export class DownwardAPIVolumeSource {
  items: DownwardAPIVolumeFile[];
  defaultMode?: number;

  constructor(init?: DownwardAPIVolumeSource) {
    if (!init) return ;
    if (init.items) this.items = init.items;
    if (init.defaultMode) this.defaultMode = init.defaultMode;
  }


  static emptyObject(): DownwardAPIVolumeSource {
    let result = new DownwardAPIVolumeSource();
    result.items = [];
    return result;
  }

}
export class FlockerVolumeSource {
  datasetName: string;
  datasetUUID: string;

  constructor(init?: FlockerVolumeSource) {
    if (!init) return ;
    if (init.datasetName) this.datasetName = init.datasetName;
    if (init.datasetUUID) this.datasetUUID = init.datasetUUID;
  }


  static emptyObject(): FlockerVolumeSource {
    let result = new FlockerVolumeSource();
    return result;
  }

}

export class CephFSVolumeSource {
  monitors: string[];
  path: string;
  user: string;
  secretFile: string;
  secretRef?: LocalObjectReference;
  readOnly: boolean;

  constructor(init?: CephFSVolumeSource) {
    if (!init) return ;
    if (init.monitors) this.monitors = init.monitors;
    if (init.path) this.path = init.path;
    if (init.user) this.user = init.user;
    if (init.secretFile) this.secretFile = init.secretFile;
    if (init.secretRef) this.secretRef = init.secretRef;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): CephFSVolumeSource {
    let result = new CephFSVolumeSource();
    result.monitors = [];
    result.secretRef = LocalObjectReference.emptyObject();
    return result;
  }

}
export class CinderVolumeSource {
  volumeID: string;
  fsType: string;
  readOnly: boolean;

  constructor(init?: CinderVolumeSource) {
    if (!init) return ;
    if (init.volumeID) this.volumeID = init.volumeID;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): CinderVolumeSource {
    let result = new CinderVolumeSource();
    return result;
  }

}

export class FlexVolumeSource {
  driver: string;
  fsType: string;
  secretRef?: LocalObjectReference;
  readOnly: boolean;
  options?: {[key: string]: string};

  constructor(init?: FlexVolumeSource) {
    if (!init) return ;
    if (init.driver) this.driver = init.driver;
    if (init.fsType) this.fsType = init.fsType;
    if (init.secretRef) this.secretRef = init.secretRef;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.options) this.options = init.options;
  }


  static emptyObject(): FlexVolumeSource {
    let result = new FlexVolumeSource();
    result.secretRef = LocalObjectReference.emptyObject();
    result.options = null;
    return result;
  }

}

export class RBDVolumeSource {
  monitors: string[];
  image: string;
  fsType: string;
  pool: string;
  user: string;
  keyring: string;
  secretRef?: LocalObjectReference;
  readOnly: boolean;

  constructor(init?: RBDVolumeSource) {
    if (!init) return ;
    if (init.monitors) this.monitors = init.monitors;
    if (init.image) this.image = init.image;
    if (init.fsType) this.fsType = init.fsType;
    if (init.pool) this.pool = init.pool;
    if (init.user) this.user = init.user;
    if (init.keyring) this.keyring = init.keyring;
    if (init.secretRef) this.secretRef = init.secretRef;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): RBDVolumeSource {
    let result = new RBDVolumeSource();
    result.monitors = [];
    result.secretRef = LocalObjectReference.emptyObject();
    return result;
  }

}
export class PersistentVolumeClaimVolumeSource {
  claimName: string;
  readOnly: boolean;

  constructor(init?: PersistentVolumeClaimVolumeSource) {
    if (!init) return ;
    if (init.claimName) this.claimName = init.claimName;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): PersistentVolumeClaimVolumeSource {
    let result = new PersistentVolumeClaimVolumeSource();
    return result;
  }

}
export class GlusterfsVolumeSource {
  endpoints: string;
  path: string;
  readOnly: boolean;

  constructor(init?: GlusterfsVolumeSource) {
    if (!init) return ;
    if (init.endpoints) this.endpoints = init.endpoints;
    if (init.path) this.path = init.path;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): GlusterfsVolumeSource {
    let result = new GlusterfsVolumeSource();
    return result;
  }

}
export class LocalObjectReference {
  name: string;

  constructor(init?: LocalObjectReference) {
    if (!init) return ;
    if (init.name) this.name = init.name;
  }


  static emptyObject(): LocalObjectReference {
    let result = new LocalObjectReference();
    return result;
  }

}
export class ISCSIVolumeSource {
  targetPortal: string;
  iqn: string;
  lun: number;
  iscsiInterface: string;
  fsType: string;
  readOnly: boolean;
  portals: string[];
  chapAuthDiscovery: boolean;
  chapAuthSession: boolean;
  secretRef?: LocalObjectReference;
  initiatorName?: string;

  constructor(init?: ISCSIVolumeSource) {
    if (!init) return ;
    if (init.targetPortal) this.targetPortal = init.targetPortal;
    if (init.iqn) this.iqn = init.iqn;
    if (init.lun) this.lun = init.lun;
    if (init.iscsiInterface) this.iscsiInterface = init.iscsiInterface;
    if (init.fsType) this.fsType = init.fsType;
    if (init.readOnly) this.readOnly = init.readOnly;
    if (init.portals) this.portals = init.portals;
    if (init.chapAuthDiscovery) this.chapAuthDiscovery = init.chapAuthDiscovery;
    if (init.chapAuthSession) this.chapAuthSession = init.chapAuthSession;
    if (init.secretRef) this.secretRef = init.secretRef;
    if (init.initiatorName) this.initiatorName = init.initiatorName;
  }


  static emptyObject(): ISCSIVolumeSource {
    let result = new ISCSIVolumeSource();
    result.portals = [];
    result.secretRef = LocalObjectReference.emptyObject();
    return result;
  }

}
export class NFSVolumeSource {
  server: string;
  path: string;
  readOnly: boolean;

  constructor(init?: NFSVolumeSource) {
    if (!init) return ;
    if (init.server) this.server = init.server;
    if (init.path) this.path = init.path;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): NFSVolumeSource {
    let result = new NFSVolumeSource();
    return result;
  }

}
export class KeyToPath {
  key: string;
  path: string;
  mode?: number;

  constructor(init?: KeyToPath) {
    if (!init) return ;
    if (init.key) this.key = init.key;
    if (init.path) this.path = init.path;
    if (init.mode) this.mode = init.mode;
  }


  static emptyObject(): KeyToPath {
    let result = new KeyToPath();
    return result;
  }

}
export class SecretVolumeSource {
  secretName: string;
  items: KeyToPath[];
  defaultMode?: number;
  optional?: boolean;

  constructor(init?: SecretVolumeSource) {
    if (!init) return ;
    if (init.secretName) this.secretName = init.secretName;
    if (init.items) this.items = init.items;
    if (init.defaultMode) this.defaultMode = init.defaultMode;
    if (init.optional) this.optional = init.optional;
  }


  static emptyObject(): SecretVolumeSource {
    let result = new SecretVolumeSource();
    result.items = [];
    return result;
  }

}
export class GitRepoVolumeSource {
  repository: string;
  revision: string;
  directory: string;

  constructor(init?: GitRepoVolumeSource) {
    if (!init) return ;
    if (init.repository) this.repository = init.repository;
    if (init.revision) this.revision = init.revision;
    if (init.directory) this.directory = init.directory;
  }


  static emptyObject(): GitRepoVolumeSource {
    let result = new GitRepoVolumeSource();
    return result;
  }

}
export class AWSElasticBlockStoreVolumeSource {
  volumeID: string;
  fsType: string;
  partition: number;
  readOnly: boolean;

  constructor(init?: AWSElasticBlockStoreVolumeSource) {
    if (!init) return ;
    if (init.volumeID) this.volumeID = init.volumeID;
    if (init.fsType) this.fsType = init.fsType;
    if (init.partition) this.partition = init.partition;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): AWSElasticBlockStoreVolumeSource {
    let result = new AWSElasticBlockStoreVolumeSource();
    return result;
  }

}
export class GCEPersistentDiskVolumeSource {
  pdName: string;
  fsType: string;
  partition: number;
  readOnly: boolean;

  constructor(init?: GCEPersistentDiskVolumeSource) {
    if (!init) return ;
    if (init.pdName) this.pdName = init.pdName;
    if (init.fsType) this.fsType = init.fsType;
    if (init.partition) this.partition = init.partition;
    if (init.readOnly) this.readOnly = init.readOnly;
  }


  static emptyObject(): GCEPersistentDiskVolumeSource {
    let result = new GCEPersistentDiskVolumeSource();
    return result;
  }

}
export class Quantity {
  Format: string;

  constructor(init?: Quantity) {
    if (!init) return ;
    if (init.Format) this.Format = init.Format;
  }


  static emptyObject(): Quantity {
    let result = new Quantity();
    return result;
  }

}
export class EmptyDirVolumeSource {
  medium: string;
  sizeLimit?: Quantity;

  constructor(init?: EmptyDirVolumeSource) {
    if (!init) return ;
    if (init.medium) this.medium = init.medium;
    if (init.sizeLimit) this.sizeLimit = init.sizeLimit;
  }


  static emptyObject(): EmptyDirVolumeSource {
    let result = new EmptyDirVolumeSource();
    result.sizeLimit = Quantity.emptyObject();
    return result;
  }

}
export class HostPathVolumeSource {
  path: string;
  type?: string;

  constructor(init?: HostPathVolumeSource) {
    if (!init) return ;
    if (init.path) this.path = init.path;
    if (init.type) this.type = init.type;
  }


  static emptyObject(): HostPathVolumeSource {
    let result = new HostPathVolumeSource();
    return result;
  }

}
export class Volume {
  name: string;
  hostPath?: HostPathVolumeSource;
  emptyDir?: EmptyDirVolumeSource;
  gcePersistentDisk?: GCEPersistentDiskVolumeSource;
  awsElasticBlockStore?: AWSElasticBlockStoreVolumeSource;
  gitRepo?: GitRepoVolumeSource;
  secret?: SecretVolumeSource;
  nfs?: NFSVolumeSource;
  iscsi?: ISCSIVolumeSource;
  glusterfs?: GlusterfsVolumeSource;
  persistentVolumeClaim?: PersistentVolumeClaimVolumeSource;
  rbd?: RBDVolumeSource;
  flexVolume?: FlexVolumeSource;
  cinder?: CinderVolumeSource;
  cephfs?: CephFSVolumeSource;
  flocker?: FlockerVolumeSource;
  downwardAPI?: DownwardAPIVolumeSource;
  fc?: FCVolumeSource;
  azureFile?: AzureFileVolumeSource;
  configMap?: ConfigMapVolumeSource;
  vsphereVolume?: VsphereVirtualDiskVolumeSource;
  quobyte?: QuobyteVolumeSource;
  azureDisk?: AzureDiskVolumeSource;
  photonPersistentDisk?: PhotonPersistentDiskVolumeSource;
  projected?: ProjectedVolumeSource;
  portworxVolume?: PortworxVolumeSource;
  scaleIO?: ScaleIOVolumeSource;
  storageos?: StorageOSVolumeSource;

  constructor(init?: Volume) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.hostPath) this.hostPath = init.hostPath;
    if (init.emptyDir) this.emptyDir = init.emptyDir;
    if (init.gcePersistentDisk) this.gcePersistentDisk = init.gcePersistentDisk;
    if (init.awsElasticBlockStore) this.awsElasticBlockStore = init.awsElasticBlockStore;
    if (init.gitRepo) this.gitRepo = init.gitRepo;
    if (init.secret) this.secret = init.secret;
    if (init.nfs) this.nfs = init.nfs;
    if (init.iscsi) this.iscsi = init.iscsi;
    if (init.glusterfs) this.glusterfs = init.glusterfs;
    if (init.persistentVolumeClaim) this.persistentVolumeClaim = init.persistentVolumeClaim;
    if (init.rbd) this.rbd = init.rbd;
    if (init.flexVolume) this.flexVolume = init.flexVolume;
    if (init.cinder) this.cinder = init.cinder;
    if (init.cephfs) this.cephfs = init.cephfs;
    if (init.flocker) this.flocker = init.flocker;
    if (init.downwardAPI) this.downwardAPI = init.downwardAPI;
    if (init.fc) this.fc = init.fc;
    if (init.azureFile) this.azureFile = init.azureFile;
    if (init.configMap) this.configMap = init.configMap;
    if (init.vsphereVolume) this.vsphereVolume = init.vsphereVolume;
    if (init.quobyte) this.quobyte = init.quobyte;
    if (init.azureDisk) this.azureDisk = init.azureDisk;
    if (init.photonPersistentDisk) this.photonPersistentDisk = init.photonPersistentDisk;
    if (init.projected) this.projected = init.projected;
    if (init.portworxVolume) this.portworxVolume = init.portworxVolume;
    if (init.scaleIO) this.scaleIO = init.scaleIO;
    if (init.storageos) this.storageos = init.storageos;
  }


  static emptyObject(): Volume {
    let result = new Volume();
    result.hostPath = HostPathVolumeSource.emptyObject();
    result.emptyDir = EmptyDirVolumeSource.emptyObject();
    result.gcePersistentDisk = GCEPersistentDiskVolumeSource.emptyObject();
    result.awsElasticBlockStore = AWSElasticBlockStoreVolumeSource.emptyObject();
    result.gitRepo = GitRepoVolumeSource.emptyObject();
    result.secret = SecretVolumeSource.emptyObject();
    result.nfs = NFSVolumeSource.emptyObject();
    result.iscsi = ISCSIVolumeSource.emptyObject();
    result.glusterfs = GlusterfsVolumeSource.emptyObject();
    result.persistentVolumeClaim = PersistentVolumeClaimVolumeSource.emptyObject();
    result.rbd = RBDVolumeSource.emptyObject();
    result.flexVolume = FlexVolumeSource.emptyObject();
    result.cinder = CinderVolumeSource.emptyObject();
    result.cephfs = CephFSVolumeSource.emptyObject();
    result.flocker = FlockerVolumeSource.emptyObject();
    result.downwardAPI = DownwardAPIVolumeSource.emptyObject();
    result.fc = FCVolumeSource.emptyObject();
    result.azureFile = AzureFileVolumeSource.emptyObject();
    result.configMap = ConfigMapVolumeSource.emptyObject();
    result.vsphereVolume = VsphereVirtualDiskVolumeSource.emptyObject();
    result.quobyte = QuobyteVolumeSource.emptyObject();
    result.azureDisk = AzureDiskVolumeSource.emptyObject();
    result.photonPersistentDisk = PhotonPersistentDiskVolumeSource.emptyObject();
    result.projected = ProjectedVolumeSource.emptyObject();
    result.portworxVolume = PortworxVolumeSource.emptyObject();
    result.scaleIO = ScaleIOVolumeSource.emptyObject();
    result.storageos = StorageOSVolumeSource.emptyObject();
    return result;
  }

}
export class PodSpec {
  volumes: Volume[];
  initContainers: Container[];
  containers: Container[];
  restartPolicy: string;
  terminationGracePeriodSeconds?: number;
  activeDeadlineSeconds?: number;
  dnsPolicy: string;
  nodeSelector?: {[key: string]: string};
  serviceAccountName: string;
  serviceAccount: string;
  automountServiceAccountToken?: boolean;
  nodeName: string;
  hostNetwork: boolean;
  hostPID: boolean;
  hostIPC: boolean;
  shareProcessNamespace?: boolean;
  securityContext?: PodSecurityContext;
  imagePullSecrets: LocalObjectReference[];
  hostname: string;
  subdomain: string;
  affinity?: Affinity;
  schedulerName: string;
  tolerations: Toleration[];
  hostAliases: HostAlias[];
  priorityClassName: string;
  priority?: number;
  dnsConfig?: PodDNSConfig;

  constructor(init?: PodSpec) {
    if (!init) return ;
    if (init.volumes) this.volumes = init.volumes;
    if (init.initContainers) this.initContainers = init.initContainers;
    if (init.containers) this.containers = init.containers;
    if (init.restartPolicy) this.restartPolicy = init.restartPolicy;
    if (init.terminationGracePeriodSeconds) this.terminationGracePeriodSeconds = init.terminationGracePeriodSeconds;
    if (init.activeDeadlineSeconds) this.activeDeadlineSeconds = init.activeDeadlineSeconds;
    if (init.dnsPolicy) this.dnsPolicy = init.dnsPolicy;
    if (init.nodeSelector) this.nodeSelector = init.nodeSelector;
    if (init.serviceAccountName) this.serviceAccountName = init.serviceAccountName;
    if (init.serviceAccount) this.serviceAccount = init.serviceAccount;
    if (init.automountServiceAccountToken) this.automountServiceAccountToken = init.automountServiceAccountToken;
    if (init.nodeName) this.nodeName = init.nodeName;
    if (init.hostNetwork) this.hostNetwork = init.hostNetwork;
    if (init.hostPID) this.hostPID = init.hostPID;
    if (init.hostIPC) this.hostIPC = init.hostIPC;
    if (init.shareProcessNamespace) this.shareProcessNamespace = init.shareProcessNamespace;
    if (init.securityContext) this.securityContext = init.securityContext;
    if (init.imagePullSecrets) this.imagePullSecrets = init.imagePullSecrets;
    if (init.hostname) this.hostname = init.hostname;
    if (init.subdomain) this.subdomain = init.subdomain;
    if (init.affinity) this.affinity = init.affinity;
    if (init.schedulerName) this.schedulerName = init.schedulerName;
    if (init.tolerations) this.tolerations = init.tolerations;
    if (init.hostAliases) this.hostAliases = init.hostAliases;
    if (init.priorityClassName) this.priorityClassName = init.priorityClassName;
    if (init.priority) this.priority = init.priority;
    if (init.dnsConfig) this.dnsConfig = init.dnsConfig;
  }


  static emptyObject(): PodSpec {
    let result = new PodSpec();
    result.volumes = [];
    result.initContainers = [];
    result.containers = [];
    result.nodeSelector = null;
    result.securityContext = PodSecurityContext.emptyObject();
    result.imagePullSecrets = [];
    result.affinity = Affinity.emptyObject();
    result.tolerations = [];
    result.hostAliases = [];
    result.dnsConfig = PodDNSConfig.emptyObject();
    return result;
  }

}

export class PodTemplateSpec {
  metadata: ObjectMeta;
  spec: PodSpec;

  constructor(init?: PodTemplateSpec) {
    if (!init) return ;
    if (init.metadata) this.metadata = init.metadata;
    if (init.spec) this.spec = init.spec;
  }


  static emptyObject(): PodTemplateSpec {
    let result = new PodTemplateSpec();
    result.metadata = ObjectMeta.emptyObject();
    result.spec = PodSpec.emptyObject();
    return result;
  }

}
export class LabelSelectorRequirement {
  key: string;
  operator: string;
  values: string[];

  constructor(init?: LabelSelectorRequirement) {
    if (!init) return ;
    if (init.key) this.key = init.key;
    if (init.operator) this.operator = init.operator;
    if (init.values) this.values = init.values;
  }


  static emptyObject(): LabelSelectorRequirement {
    let result = new LabelSelectorRequirement();
    result.values = [];
    return result;
  }

}
export class LabelSelector {
  matchLabels?: {[key: string]: string};
  matchExpressions: LabelSelectorRequirement[];

  constructor(init?: LabelSelector) {
    if (!init) return ;
    if (init.matchLabels) this.matchLabels = init.matchLabels;
    if (init.matchExpressions) this.matchExpressions = init.matchExpressions;
  }


  static emptyObject(): LabelSelector {
    let result = new LabelSelector();
    result.matchLabels = null;
    result.matchExpressions = [];
    return result;
  }

}
export class DaemonSetSpec {
  selector?: LabelSelector;
  template: PodTemplateSpec;
  updateStrategy: DaemonSetUpdateStrategy;
  minReadySeconds: number;
  templateGeneration: number;
  revisionHistoryLimit?: number;

  constructor(init?: DaemonSetSpec) {
    if (!init) return ;
    if (init.selector) this.selector = init.selector;
    if (init.template) this.template = init.template;
    if (init.updateStrategy) this.updateStrategy = init.updateStrategy;
    if (init.minReadySeconds) this.minReadySeconds = init.minReadySeconds;
    if (init.templateGeneration) this.templateGeneration = init.templateGeneration;
    if (init.revisionHistoryLimit) this.revisionHistoryLimit = init.revisionHistoryLimit;
  }


  static emptyObject(): DaemonSetSpec {
    let result = new DaemonSetSpec();
    result.selector = LabelSelector.emptyObject();
    result.template = PodTemplateSpec.emptyObject();
    result.updateStrategy = DaemonSetUpdateStrategy.emptyObject();
    return result;
  }

}
export class StatusCause {
  reason: string;
  message: string;
  field: string;

  constructor(init?: StatusCause) {
    if (!init) return ;
    if (init.reason) this.reason = init.reason;
    if (init.message) this.message = init.message;
    if (init.field) this.field = init.field;
  }


  static emptyObject(): StatusCause {
    let result = new StatusCause();
    return result;
  }

}
export class StatusDetails {
  name: string;
  group: string;
  kind: string;
  uid: string;
  causes: StatusCause[];
  retryAfterSeconds: number;

  constructor(init?: StatusDetails) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.group) this.group = init.group;
    if (init.kind) this.kind = init.kind;
    if (init.uid) this.uid = init.uid;
    if (init.causes) this.causes = init.causes;
    if (init.retryAfterSeconds) this.retryAfterSeconds = init.retryAfterSeconds;
  }


  static emptyObject(): StatusDetails {
    let result = new StatusDetails();
    result.causes = [];
    return result;
  }

}
export class ListMeta {
  selfLink: string;
  resourceVersion: string;
  continue: string;

  constructor(init?: ListMeta) {
    if (!init) return ;
    if (init.selfLink) this.selfLink = init.selfLink;
    if (init.resourceVersion) this.resourceVersion = init.resourceVersion;
    if (init.continue) this.continue = init.continue;
  }


  static emptyObject(): ListMeta {
    let result = new ListMeta();
    return result;
  }

}
export class Status {
  kind: string;
  apiVersion: string;
  metadata: ListMeta;
  status: string;
  message: string;
  reason: string;
  details?: StatusDetails;
  code: number;

  constructor(init?: Status) {
    if (!init) return ;
    if (init.kind) this.kind = init.kind;
    if (init.apiVersion) this.apiVersion = init.apiVersion;
    if (init.metadata) this.metadata = init.metadata;
    if (init.status) this.status = init.status;
    if (init.message) this.message = init.message;
    if (init.reason) this.reason = init.reason;
    if (init.details) this.details = init.details;
    if (init.code) this.code = init.code;
  }


  static emptyObject(): Status {
    let result = new Status();
    result.metadata = ListMeta.emptyObject();
    result.details = StatusDetails.emptyObject();
    return result;
  }

}
export class Initializer {
  name: string;

  constructor(init?: Initializer) {
    if (!init) return ;
    if (init.name) this.name = init.name;
  }


  static emptyObject(): Initializer {
    let result = new Initializer();
    return result;
  }

}
export class Initializers {
  pending: Initializer[];
  result?: Status;

  constructor(init?: Initializers) {
    if (!init) return ;
    if (init.pending) this.pending = init.pending;
    if (init.result) this.result = init.result;
  }


  static emptyObject(): Initializers {
    let result = new Initializers();
    result.pending = [];
    result.result = Status.emptyObject();
    return result;
  }

}
export class OwnerReference {
  apiVersion: string;
  kind: string;
  name: string;
  uid: string;
  controller?: boolean;
  blockOwnerDeletion?: boolean;

  constructor(init?: OwnerReference) {
    if (!init) return ;
    if (init.apiVersion) this.apiVersion = init.apiVersion;
    if (init.kind) this.kind = init.kind;
    if (init.name) this.name = init.name;
    if (init.uid) this.uid = init.uid;
    if (init.controller) this.controller = init.controller;
    if (init.blockOwnerDeletion) this.blockOwnerDeletion = init.blockOwnerDeletion;
  }


  static emptyObject(): OwnerReference {
    let result = new OwnerReference();
    return result;
  }

}


export class Time {
  Time: Date;

  constructor(init?: Time) {
    if (!init) return ;
    if (init.Time) this.Time = new Date(init.Time as any);
  }


  static emptyObject(): Time {
    let result = new Time();
    result.Time = null;
    return result;
  }

}
export class ObjectMeta {
  name: string;
  generateName: string;
  namespace: string;
  selfLink: string;
  uid: string;
  resourceVersion: string;
  generation: number;
  creationTimestamp: Time;
  deletionTimestamp?: Time;
  deletionGracePeriodSeconds?: number;
  labels?: {[key: string]: string};
  annotations?: {[key: string]: string};
  ownerReferences: OwnerReference[];
  initializers?: Initializers;
  finalizers: string[];
  clusterName: string;

  constructor(init?: ObjectMeta) {
    if (!init) return ;
    if (init.name) this.name = init.name;
    if (init.generateName) this.generateName = init.generateName;
    if (init.namespace) this.namespace = init.namespace;
    if (init.selfLink) this.selfLink = init.selfLink;
    if (init.uid) this.uid = init.uid;
    if (init.resourceVersion) this.resourceVersion = init.resourceVersion;
    if (init.generation) this.generation = init.generation;
    if (init.creationTimestamp) this.creationTimestamp = init.creationTimestamp;
    if (init.deletionTimestamp) this.deletionTimestamp = init.deletionTimestamp;
    if (init.deletionGracePeriodSeconds) this.deletionGracePeriodSeconds = init.deletionGracePeriodSeconds;
    if (init.labels) this.labels = init.labels;
    if (init.annotations) this.annotations = init.annotations;
    if (init.ownerReferences) this.ownerReferences = init.ownerReferences;
    if (init.initializers) this.initializers = init.initializers;
    if (init.finalizers) this.finalizers = init.finalizers;
    if (init.clusterName) this.clusterName = init.clusterName;
  }


  static emptyObject(): ObjectMeta {
    let result = new ObjectMeta();
    result.creationTimestamp = Time.emptyObject();
    result.deletionTimestamp = Time.emptyObject();
    result.labels = null;
    result.annotations = null;
    result.ownerReferences = [];
    result.initializers = Initializers.emptyObject();
    result.finalizers = [];
    return result;
  }

}
export class KubeDaemonSet {
  kind: string;
  apiVersion: string;
  metadata: ObjectMeta;
  spec: DaemonSetSpec;
  status: DaemonSetStatus;

  constructor(init?: KubeDaemonSet) {
    if (!init) return ;
    if (init.kind) this.kind = init.kind;
    if (init.apiVersion) this.apiVersion = init.apiVersion;
    if (init.metadata) this.metadata = init.metadata;
    if (init.spec) this.spec = init.spec;
    if (init.status) this.status = init.status;
  }


  static emptyObject(): KubeDaemonSet {
    let result = new KubeDaemonSet();
    result.metadata = ObjectMeta.emptyObject();
    result.spec = DaemonSetSpec.emptyObject();
    result.status = DaemonSetStatus.emptyObject();
    return result;
  }

}
